home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 17 / CU Amiga Magazine's Super CD-ROM 17 (1997)(EMAP Images)(GB)[!][issue 1997-12].iso / CUCD / Programming / DiceSource / src / hunks / hunks.c < prev    next >
C/C++ Source or Header  |  1997-09-09  |  6KB  |  299 lines
  1. /*
  2.  *    (c)Copyright 1992-1997 Obvious Implementations Corp.  Redistribution and
  3.  *    use is allowed under the terms of the DICE-LICENSE FILE,
  4.  *    DICE-LICENSE.TXT.
  5.  */
  6. /*
  7.  *    (c)Copyright 1992-1997 Obvious Implementations Corp.  Redistribution and
  8.  *    use is allowed under the terms of the DICE-LICENSE FILE,
  9.  *    DICE-LICENSE.TXT.
  10.  */
  11.  
  12. /*
  13.  *  HUNKS.C
  14.  *
  15.  *  HUNKS executable
  16.  *
  17.  */
  18.  
  19. #include <stdio.h>
  20. #include <stdlib.h>
  21. #include <string.h>
  22.  
  23. #ifdef AMIGA
  24. #include <lib/version.h>
  25. #else
  26. #include <include/lib/version.h>
  27. #include <suplib/all.h>
  28. #define __aligned
  29. #endif
  30.  
  31. IDENT("hunks",".3");
  32. DCOPYRIGHT;
  33.  
  34. typedef unsigned char ubyte;
  35. typedef unsigned short uword;
  36. typedef unsigned long ulong;
  37.  
  38. void DumpHunks(char *);
  39. ulong fgetl(FILE *);
  40. void fgetname(FILE *, char *, long);
  41. void zfseek(FILE *, long);
  42.  
  43. short AllOpt;
  44.  
  45. int
  46. main(int ac, char **av)
  47. {
  48.     short i;
  49.  
  50. #ifndef unix
  51.     expand_args(ac, av, &ac, &av);
  52. #endif
  53.  
  54.     if (ac == 1) {
  55.     printf("%s\n%s\n", Ident, DCopyright);
  56.     puts("hunks [-all] executeable/object_module");
  57.     exit(0);
  58.     }
  59.     for (i = 1; i < ac; ++i) {
  60.     char *ptr = av[i];
  61.  
  62.     if (*ptr != '-') {
  63.         printf("\n** FILE %s **\n\n", ptr);
  64.         DumpHunks(ptr);
  65.         continue;
  66.     }
  67.     if (stricmp(ptr, "-all") == 0)
  68.         AllOpt = 1;
  69.     }
  70.     return(0);
  71. }
  72.  
  73. void
  74. DumpHunks(fileName)
  75. char *fileName;
  76. {
  77.     FILE *fi;
  78.     __aligned char buf[256];
  79.  
  80.     if ((fi = fopen(fileName, "r")) != NULL) {
  81.     ulong type;
  82.     ulong flags;
  83.     ulong skip;
  84.     ulong n;
  85.  
  86.     while ((type = fgetl(fi)) != 0) {
  87.         skip = 0;
  88.  
  89.         flags = type & 0xFFFF0000;
  90.         type  = type & 0x0000FFFF;
  91.  
  92.         switch(type) {
  93.         case 0x3F3:         /*    HUNK_HEADER */
  94.         {
  95.             long hno;
  96.  
  97.             n = fgetl(fi);
  98.             fgetname(fi, buf, n);
  99.             skip = fgetl(fi);
  100.             printf("%08x HUNK_HEADER\tname=%s\tsize=%ld ", 0x3F3, buf, skip);
  101.             printf("first=%ld ", (hno = fgetl(fi)));
  102.             printf("last=%ld\n", fgetl(fi));
  103.  
  104.             while (skip) {
  105.             --skip;
  106.             n = fgetl(fi);
  107.             printf("    %08lx HUNK %ld SIZE %ld", n, hno, (n & 0x00FFFFFF) * 4);
  108.             switch(n & 0xC0000000) {
  109.             case 0x00000000:
  110.                 break;
  111.             case 0x40000000:
  112.                 printf(" MEMF_CHIP");
  113.                 break;
  114.             case 0x80000000:
  115.                 printf(" MEMF_FAST");
  116.                 break;
  117.             case 0xC0000000:
  118.                 printf(" MEMF_CHIP|MEMF_FAST");
  119.                 break;
  120.             }
  121.             puts("");
  122.             ++hno;
  123.             }
  124.         }
  125.         break;
  126.         case 0x3E9:         /*    HUNK_CODE   */
  127.         skip = fgetl(fi);
  128.         printf("%08lx HUNK_CODE\tsize=%ld\n", type, skip * 4);
  129.         break;
  130.         case 0x3EA:         /*    HUNK_DATA    */
  131.         skip = fgetl(fi);
  132.         printf("%08lx HUNK_DATA\tsize=%ld\n", type, skip * 4);
  133.         break;
  134.         break;
  135.         case 0x3EB:         /*    HUNK_BSS    */
  136.         skip = fgetl(fi);
  137.         printf("%08lx HUNK_BSS\tsize=%ld\n", type, skip * 4);
  138.         skip = 0;
  139.         break;
  140.         case 0x3EC:         /*    HUNK_RELOC32    */
  141.         printf("%08lx HUNK_RELOC-ABSOLUTE32\n", type);
  142.         case 0x3ED:         /*    HUNK_RELOC16-PC */
  143.         if (type == 0x3ED)
  144.             printf("%08lx HUNK_RELOC-PCREL16\n", type);
  145.         case 0x3EE:         /*    HUNK_RELOC8    */
  146.         if (type == 0x3EE)
  147.             printf("%08lx HUNK_RELOC-PCREL8\n", type);
  148.         case 0x3F8:         /*    HUNK_RELOC16-D    (special) */
  149.         if (type == 0x3F8)
  150.             printf("%08lx HUNK_RELOC-DATAREL16\n", type);
  151.         while ((skip = fgetl(fi)) != 0) {
  152.             n = fgetl(fi);
  153.             printf("    %ld relocations to hunk %ld\n", skip, n);
  154.             if (AllOpt) {
  155.             while (skip) {
  156.                 --skip;
  157.                 n = fgetl(fi);
  158.                 printf("\t@0x%08lx\n", n);
  159.             }
  160.             } else {
  161.             zfseek(fi, skip);
  162.             }
  163.         }
  164.         break;
  165.         case 0x3EF:         /*    HUNK_EXT    */
  166.         printf("%08lx HUNK_EXT\n", type);
  167.         case 0x3F0:         /*    HUNK_SYMBOL    */
  168.         if (type == 0x3F0)
  169.             printf("%08lx HUNK_SYMBOL\n", type);
  170.         while ((skip = fgetl(fi)) != 0) {
  171.             ubyte symType = skip >> 24;
  172.  
  173.             skip &= 0x00FFFFFF;
  174.             fgetname(fi, buf, skip);
  175.             printf("    0x%02x:%-15s", symType, buf);
  176.  
  177.             switch(symType) {
  178.             case 0:        /*    SYMB    */
  179.             printf("\tSYMBOL");
  180.             case 1:        /*    DEF    */
  181.             if (symType == 1)
  182.                 printf("\tXDEF");
  183.             case 2:        /*    ABS    */
  184.             if (symType == 2)
  185.                 printf("\tABS-SYM");
  186.             case 3:        /*    RES    */
  187.             if (symType == 3)
  188.                 printf("\tRES-SYM");
  189.             n = fgetl(fi);
  190.             printf("\tval=0x%08lx", n);
  191.             break;
  192.             case 130:        /*    COMMON (def)*/
  193.             n = fgetl(fi);
  194.             printf("\tCOMMON size=0x%04lx", n);
  195.             break;
  196.             case 135:        /*    REF32-pc    */
  197.             printf("\tPCREL-32");
  198.             case 129:        /*    REF32        */
  199.             if (symType == 129)
  200.                 printf("\tABSOLUTE-32");
  201.             case 131:        /*    REF16-pc    */
  202.             if (symType == 131)
  203.                 printf("\tPCREL-16");
  204.             case 132:        /*    REF8        */
  205.             if (symType == 132)
  206.                 printf("\tPCREL-8");
  207.             case 134:        /*    REF16D        */
  208.             if (symType == 134)
  209.                 printf("\tDATAREL-16");
  210.             n = fgetl(fi);
  211.             printf("\t%ld relocs", n);
  212.             zfseek(fi, n);
  213.             break;
  214.             default:
  215.             printf("\tUNKNOWN TYPE FIELD");
  216.             }
  217.             puts("");
  218.         }
  219.         break;
  220.         case 0x3F1:         /*    HUNK_DEBUG        */
  221.         skip = fgetl(fi);
  222.         printf("%08lx HUNK_DEBUG\t%ld bytes\n", type, skip * 4);
  223.         break;
  224.         case 0x3E8:
  225.         n = fgetl(fi);
  226.         fgetname(fi, buf, n);
  227.         printf("%08lx HUNK_NAME\tname=%s\n", type, buf);
  228.         break;
  229.         case 0x3E7:
  230.         n = fgetl(fi);
  231.         fgetname(fi, buf, n);
  232.         printf("%08lx HUNK_UNIT\tname=%s\n", type, buf);
  233.         break;
  234.         case 0x3F2:
  235.         printf("%08lx HUNK_END\n\n", type);
  236.         break;
  237.         default:
  238.         printf("%08lx UNKNOWN HUNK TYPE\n", type);
  239.         break;
  240.         }
  241.         if (skip)
  242.         zfseek(fi, skip);
  243.     }
  244.     }
  245. }
  246.  
  247. ulong
  248. fgetl(fi)
  249. FILE *fi;
  250. {
  251.     ulong n;
  252.     short c;
  253.  
  254.     if ((c = getc(fi)) != EOF) {
  255.     n = c << 24;
  256.     if ((c = getc(fi)) != EOF) {
  257.         n |= c << 16;
  258.         if ((c = getc(fi)) != EOF) {
  259.         n |= c << 8;
  260.         if ((c = getc(fi)) != EOF) {
  261.             n |= c;
  262.             return(FromMsbOrder(n));
  263.         }
  264.         }
  265.     }
  266.     }
  267.     return(0);
  268. }
  269.  
  270. void
  271. fgetname(fi, buf, len)
  272. FILE *fi;
  273. char *buf;
  274. long len;
  275. {
  276.     long n;
  277.  
  278.     for (n = 0; n < len && n < 255/4; ++n) {
  279.     *((long *)buf + n) = ToMsbOrder(fgetl(fi));
  280.     }
  281.     *((long *)buf + n) = ToMsbOrder(0);
  282. }
  283.  
  284. void
  285. zfseek(fi, numLongs)
  286. FILE *fi;
  287. long numLongs;
  288. {
  289.     if (numLongs < 32) {
  290.     while (numLongs) {
  291.         --numLongs;
  292.         fgetl(fi);
  293.     }
  294.     } else {
  295.     fseek(fi, numLongs * 4, 1);
  296.     }
  297. }
  298.  
  299.